Atom AI Labs - AI-Powered Multi-Tenant Platform

Workflow Builder User Guide

**Last Updated:** 2026-03-28

**Version:** 1.0.0

Getting Started
Using Templates
Working with Nodes
Connecting Nodes
Configuring Workflows
Variables and Inputs
Testing and Execution
Saving and Sharing
Tips and Best Practices
Troubleshooting

---

Getting Started

Accessing the Visual Workflow Builder

The Visual Workflow Builder is accessible from the Automations section of your ATUM SaaS dashboard.

**Navigation:**

Log in to your ATUM SaaS account
Navigate to **Automations** in the left sidebar
Click **Workflow Builder** to launch the visual editor

**Prerequisites:**

Active ATUM SaaS account (Free, Solo, Team, or Enterprise tier)
Appropriate plan permissions (see Plan Limits)
Integrations connected (for integration workflows)

Interface Overview

The Workflow Builder consists of three main areas:

**1. Canvas (Center)**

Visual workspace for building workflows
Drag-and-drop node placement
Visual connection lines between nodes
Pan and zoom controls

**2. Sidebar (Left)**

Template browser
Node palette (triggers, actions, integrations, entities, agents)
Workflow settings
Variable substitution panel

**3. Toolbar (Top)**

Execute workflow button
Save workflow button
Save as template button
Undo/redo buttons
Clear canvas button
Help button

Quick Start: Create Your First Workflow

Let's create a simple workflow that sends a Slack message when a new lead is created.

**Step 1: Choose a Template**

Click **Templates** in the sidebar
Browse available templates or start from scratch
For this example, click **Start Blank Workflow**

**Step 2: Add a Trigger Node**

Click **Triggers** in the sidebar
Drag **Webhook Trigger** to the canvas
Configure the webhook URL (auto-generated)

**Step 3: Add an Integration Node**

Click **Integrations** in the sidebar
Select **Slack**
Drag **Send Message** to the canvas
Connect the trigger to the Slack node

**Step 4: Configure the Slack Message**

Click the Slack node to select it
In the configuration panel, enter:

Channel: #sales
Message: New lead created: ${input.name}

Click **Save**

**Step 5: Test Your Workflow**

Click **Test Workflow** in the toolbar
Enter test input: {"name": "John Doe"}
Click **Run Test**
Check your Slack channel for the message

**Step 6: Save Your Workflow**

Click **Save Workflow** in the toolbar
Enter a name: "Lead Notification Workflow"
Click **Save**

Congratulations! You've created your first workflow.

---

Using Templates

Browsing Template Gallery

The Template Gallery provides pre-built workflows for common use cases.

**Access:**

Click **Templates** in the sidebar
Browse by category:

**Integration**: Connect two or more services
**Automation**: Automate repetitive tasks
**Approval**: Multi-step approval workflows

**Template Categories:**

Category	Description	Examples
Integration	Connect different services	Salesforce to Slack, Zoom to Notion
Automation	Automate tasks	Email follow-ups, data sync
Approval	Multi-step approvals	Budget approval, document review

Filtering by Category

**Quick Filter Tabs:**

**All**: Show all templates
**Integration**: Integration workflows only
**Automation**: Automation workflows only
**Approval**: Approval workflows only

**How to Filter:**

Click the desired category tab
Templates update instantly

Previewing Templates

Before loading a template, you can preview its structure.

**Preview Features:**

Template name and description
Number of steps
Complexity level (beginner, intermediate, advanced, expert)
Required integrations
Step overview

**How to Preview:**

Hover over a template card
Click **Preview** button
Review template details
Click **Load Template** to use it

Loading Template into Canvas

**Steps:**

Browse templates in the sidebar
Click on a template card
Review template in preview panel
Click **Load Template**
Template appears on canvas with all nodes and connections

**What Happens:**

Template steps are converted to visual nodes
Nodes are automatically positioned (tree layout)
Connections are created between nodes
Template inputs are extracted
Variable references are identified

Customizing Loaded Templates

Once loaded, you can customize the template:

**Customization Options:**

**Add Nodes**: Drag additional nodes from the sidebar
**Remove Nodes**: Select a node and press Delete/Backspace
**Reconfigure Nodes**: Click a node to edit its configuration
**Change Connections**: Drag connection lines to different nodes
**Modify Variables**: Update variable references in the Variable Panel

**Example: Customize a Template**

Load "Salesforce to Slack Sync" template
Add a filter node to only sync qualified leads
Change the Slack channel from #sales to #leads
Add an email notification step
Save as a new template

---

Working with Nodes

Adding Nodes to Canvas

**Methods:**

**1. Drag and Drop (Recommended)**

Click a node type in the sidebar
Drag it onto the canvas
Release to place the node

**2. Click to Add**

Click a node type in the sidebar
Node appears in the center of the canvas
Drag to reposition

**3. Keyboard Shortcuts**

Press T for trigger node
Press A for action node
Press I for integration node
Press E for entity node
Press G for agent node

Integration Nodes

Integration nodes connect to 39+ external services like Slack, Salesforce, Gmail, etc.

**Available Integrations:**

**Communication:**

Slack: Send messages, create channels
Gmail: Send emails, label messages
Microsoft Teams: Send messages, create channels

**CRM:**

Salesforce: Create leads, query contacts
HubSpot: Create contacts, update deals
Pipedrive: Create deals, update activities

**Project Management:**

Asana: Create tasks, update projects
Notion: Create pages, update databases
Trello: Create cards, update lists

**Productivity:**

Zoom: Create meetings, list recordings
Google Calendar: Create events, list calendars
Dropbox: Upload files, create folders

**And 30+ more integrations!**

**Configuring Integration Nodes:**

**Step 1: Select Integration**

Click **Integrations** in the sidebar
Browse or search for your integration
Check connection status (green = connected, red = not connected)

**Step 2: Choose Operation**

After selecting an integration, view available operations
Click an operation to add it to the canvas
Examples:

Slack: Send Message, Create Channel
Salesforce: Create Lead, Query Contacts
Gmail: Send Email, List Messages

**Step 3: Configure Parameters**

Click the integration node on the canvas
Fill in required parameters:

**Static values**: Enter fixed values (e.g., channel name)
**Variable references**: Use ${input.field} or ${step_N.field} for dynamic values

Click **Save**

**Example: Send Slack Message**

Integration: Slack
Operation: Send Message
Parameters:
  - channel: ${input.slack_channel}  (variable)
  - message: New lead: ${input.lead_name}  (variable)

**Connection Status:**

**Green Badge**: Integration is connected and ready to use
**Red Badge**: Integration needs OAuth connection
**Click to Connect**: Opens OAuth flow in popup window

Entity Nodes

Entity nodes perform CRUD operations on your custom entity types (Leads, Tasks, Deals, etc.).

**Available Entity Types:**

Leads: Potential customers
Tasks: Action items
Deals: Sales opportunities
Custom entities: Any entity type you've created

**Entity Operations:**

Operation	Description	Maturity Required
Create	Create a new entity	Intern+
Read	Read an existing entity	Student+
Update	Update an existing entity	Supervised+
Delete	Delete an entity	Autonomous
Query	List entities with filters	Student+

**Configuring Entity Nodes:**

**Step 1: Select Entity Type**

Click **Entities** in the sidebar
Choose an entity type (e.g., Lead)
View entity schema (fields and types)

**Step 2: Choose Operation**

Select an operation (Create, Read, Update, Delete, Query)
Check maturity level requirement
Click to add to canvas

**Step 3: Configure Parameters**

Click the entity node on the canvas
Fill in entity data:

**Create**: Provide all required fields
**Read**: Provide entity ID
**Update**: Provide entity ID and fields to update
**Delete**: Provide entity ID
**Query**: Provide filter criteria

Click **Save**

**Example: Create Lead**

Entity Type: Lead
Operation: Create
Parameters:
  - first_name: ${input.first_name}
  - last_name: ${input.last_name}
  - email: ${input.email}
  - status: "new"
  - source: "webform"

**Maturity Color Coding:**

**Gray**: Student (read-only)
**Blue**: Intern (create with approval)
**Yellow**: Supervised (create/update with monitoring)
**Green**: Autonomous (full CRUD)

Agent Nodes

Agent nodes execute AI agents with specific tasks and prompts.

**Agent Maturity Levels:**

Level	Capabilities	Restrictions
Student	Read-only, search, browse	Cannot take actions
Intern	Propose actions, create drafts	Approval required for actions
Supervised	Execute most actions	Live monitoring required
Autonomous	Full access, can supervise others	No restrictions

**Configuring Agent Nodes:**

**Step 1: Select Agent**

Click **Agents** in the sidebar
Browse your agents
View agent maturity level and capabilities
Click to add to canvas

**Step 2: Configure Task**

Click the agent node on the canvas
Enter a task prompt:

Be specific about what you want the agent to do
Include context from previous steps using variables
Specify output format if needed

Click **Save**

**Example: Analyze Lead**

Agent: Sales Assistant
Maturity: Intern
Task Prompt: |
  Analyze this lead and determine if they qualify for follow-up.
  Lead data: ${step_create_lead.output}
  Consider:
  - Company size
  - Industry
  - Job title
  - Location
  Return: score (0-100) and reasoning

**Governance Display:**

Student: "Read-only access - no actions allowed"
Intern: "Approval required for actions"
Supervised: "Live monitoring enabled"
Autonomous: "Full access - can supervise other agents"

Trigger Nodes

Trigger nodes define how workflows are initiated.

**Trigger Types:**

**1. Webhook Trigger**

HTTP endpoint that starts workflow
Receives JSON payload
Useful for external systems

**Configuration:**

Webhook URL (auto-generated)
Input schema (define expected JSON structure)
Authentication (optional API key)

**Example:**

Trigger Type: Webhook
URL: https://atomagentos.com/api/webhooks/wh-abc123
Input Schema:
  {
    "type": "object",
    "properties": {
      "email": {"type": "string"},
      "name": {"type": "string"},
      "company": {"type": "string"}
    }
  }

**2. Schedule Trigger**

Cron-based scheduling
Recurring execution
Useful for batch jobs

**Configuration:**

Cron expression (e.g., 0 9 * * 1 for every Monday at 9am)
Timezone
Input parameters (static values)

**Example:**

Trigger Type: Schedule
Cron: 0 9 * * 1  (Every Monday at 9am)
Timezone: America/New_York
Input: {}

**3. Manual Trigger**

Start workflow manually
No automatic triggering
Useful for testing and one-off tasks

**Configuration:**

Input schema (define required inputs)

Control Flow Nodes

Control flow nodes manage workflow logic and branching.

**Condition Node**

Branch workflow based on conditions
Support true/false paths
Variable substitution in conditions

**Example:**

Condition: ${step_1.score} > 80
True Path: Create qualified lead
False Path: Create unqualified lead

**Loop Node**

Iterate over arrays
Process items in batch
Continue until condition met

**Example:**

Loop Over: ${step_query_leads.results}
Max Iterations: 100
Condition: item.status == "new"

---

Connecting Nodes

Creating Connections Between Nodes

Connections define the order in which workflow steps execute.

**Methods:**

**1. Drag from Output Port**

Hover over a node to reveal connection points
Click and drag from the right-side output port
Drag to another node's input port (left side)
Release to create connection

**2. Auto-Connect**

When you add a node near an existing node
Connection is created automatically
Drag to reposition if needed

**3. Connection Panel**

Select a node
In the configuration panel, click **Add Dependency**
Select the node to depend on
Connection is created

Setting Up Conditional Paths

Use condition nodes to create branching workflows.

**Example: Lead Qualification Workflow**

Webhook Trigger
  ↓
Condition: Is lead qualified? (${step_1.score} > 80)
  ↓                    ↓
True (Qualified)    False (Not Qualified)
  ↓                    ↓
Create Task          Send Email
  ↓                    ↓
Notify Sales         Archive Lead

**Setting Up:**

Add a Condition node after the assessment step
Configure the condition: ${step_assess.score} > 80
Add nodes for true path (e.g., Create Task)
Add nodes for false path (e.g., Send Email)
Connect nodes to appropriate condition outputs

**Branching Best Practices:**

Always handle both true and false paths
Use clear condition names
Label branches with descriptive text
Test each branch independently

Branching Workflows

Create complex workflows with multiple branches and merges.

**Example: Multi-Channel Notification**

New Lead Created
  ↓
Check Preferred Channel
  ↓         ↓         ↓
Email     Slack     SMS
  ↓         ↓         ↓
  ←─────────┴─────────→
         ↓
    Log Notification

**Branching Patterns:**

**1. Parallel Execution**

Multiple branches execute simultaneously
All branches complete before next step
Useful for multi-channel notifications

**2. Exclusive Split**

Only one branch executes based on condition
Other branches are skipped
Useful for if/else logic

**3. Merge**

Multiple branches converge to single node
Waits for all branches to complete
Useful for aggregating results

---

Configuring Workflows

Node Configuration Panel

When you select a node on the canvas, the configuration panel appears on the right side.

**Panel Sections:**

**1. Node Info**

Node name (editable)
Node type badge
Node description

**2. Parameters**

Required parameters (marked with *)
Optional parameters
Parameter types (string, number, boolean, etc.)
Help text for each parameter

**3. Variable Substitution**

Available variables list
Variable preview
Insert variable button

**4. Advanced Settings**

Error handling (continue, stop, retry)
Timeout settings
Retry policy
Logging level

Setting Parameters

**Parameter Types:**

**1. Text Input**

For short text values
Example: Channel name, email subject
Supports variable substitution

**2. Text Area**

For long text values
Example: Email body, message content
Supports variable substitution and multi-line

**3. Number Input**

For numeric values
Example: Timeout, retry count
Min/max validation

**4. Select Dropdown**

Choose from predefined options
Example: Priority, status
Single or multi-select

**5. Boolean Toggle**

Yes/no or on/off values
Example: Enable notifications, strict mode

**6. JSON Editor**

For complex data structures
Example: Filter criteria, API payloads
Syntax highlighting and validation

**Example: Configure Slack Message**

Parameter: channel
Type: Text Input
Value: ${input.slack_channel}

Parameter: message
Type: Text Area
Value: |
  New lead received!
  Name: ${input.name}
  Email: ${input.email}
  Company: ${input.company}

Parameter: username
Type: Text Input
Value: ATUM Bot

Parameter: icon_emoji
Type: Select Dropdown
Value: :robot_face:

Using Variables

Variables enable dynamic workflow behavior.

**Variable Types:**

**1. Input Variables**

Reference template input values
Format: ${input.field_name}
Evaluated at workflow start

**Example:**

Message: Hello ${input.name}, welcome to ATUM!

**2. Step Output Variables**

Reference outputs from previous steps
Format: ${step_N.field_name} (N = step index)
Format: ${step_step_id.field_name} (step_id = step identifier)
Evaluated during workflow execution

**Example:**

Message: Lead created with ID: ${step_create_lead.lead_id}

**3. Nested Variables**

Reference nested fields in objects
Use dot notation: ${step_1.data.field.nested_field}
Supports array indexing: ${step_1.items[0].name}

**Example:**

Email: ${step_query_leads.results[0].email}

Variable Reference Syntax

**Basic Syntax:**

${source.field_path}

**Sources:**

input: Template input values
step_N: Step output by index (0-based)
step_step_id: Step output by step ID

**Field Paths:**

Use dot notation for nested fields
Use bracket notation for array indices
Support special characters with quotes

**Examples:**

${input.name}
${step_1.output.lead_id}
${step_create_lead.email}
${step_1.results[0].status}
${step_1.data['field-with-dash']}

**Validation:**

Variables are validated when you save the workflow
Invalid variables show error messages
Variable sources must exist
Field paths must be accessible

---

Variables and Inputs

Understanding ${input.field} Variables

Input variables allow workflows to accept external data.

**Use Cases:**

Webhook payloads
User-provided parameters
Scheduled job parameters
Test data

**Defining Input Variables:**

**1. In Workflow Settings**

Click **Settings** in the toolbar
Go to **Inputs** tab
Click **Add Input**
Configure input:

Name: lead_name
Label: Lead Name
Type: text
Required: Yes
Default Value: John Doe
Help Text: Enter the lead's full name

Click **Save**

**2. In Template**

When creating a template, define inputs in the template schema:

{
  "inputs": [
    {
      "name": "lead_name",
      "label": "Lead Name",
      "type": "string",
      "required": true,
      "default_value": "John Doe",
      "help_text": "Enter the lead's full name",
      "validation_rules": {
        "min_length": 2,
        "max_length": 100
      }
    }
  ]
}

**Using Input Variables:**

Message: New lead: ${input.lead_name}

Using ${step_N.field} References

Step references pass data between workflow steps.

**Step Indexing:**

Steps are indexed starting from 0
Index is based on execution order, not canvas position
Use step ID for more readable references

**Example Workflow:**

Step 0: Webhook Trigger
Step 1: Create Salesforce Lead
Step 2: Send Slack Message

**Referencing Step 1 Output from Step 2:**

Message: Lead created with ID: ${step_1.lead_id}

**Using Step IDs (Recommended):**

Message: Lead created with ID: ${step_create_lead.lead_id}

**Output Schema:**

Each step outputs specific fields. Check the step documentation for available fields.

**Example: Create Lead Output:**

{
  "lead_id": "001xx000003DGb2A",
  "success": true,
  "errors": []
}

**Referencing Output Fields:**

Lead ID: ${step_create_lead.lead_id}
Success: ${step_create_lead.success}

Variable Substitution Panel

The Variable Substitution Panel shows all variables in your workflow and allows you to provide input values.

**Access:**

Click **Variables** in the sidebar
Panel shows:

Template inputs
Step output variables
Variable values
Variable sources

**Features:**

**1. Variable Extraction**

Automatically extracts variables from workflow
Shows variable sources (input vs. step)
Groups variables by source

**2. Variable Validation**

Validates variable syntax
Checks variable sources exist
Shows errors for invalid variables

**3. Input Value Entry**

Provide values for input variables
Preview resolved values
Test variable substitution

**4. Variable Preview**

Shows how variables will be resolved
Displays final values after substitution
Updates in real-time

**Example: Variable Panel**

Input Variables:
  lead_name (required)
    Value: John Doe
    Type: text

  slack_channel (required)
    Value: #sales
    Type: text

Step Output Variables:
  step_create_lead.lead_id
    Source: Create Salesforce Lead
    Type: string
    Value: (will be set during execution)

  step_create_lead.success
    Source: Create Salesforce Lead
    Type: boolean
    Value: (will be set during execution)

Providing Input Values

**When Testing:**

Click **Test Workflow** in the toolbar
Variable Panel appears with input fields
Enter values for required inputs
Optional: Enter values for optional inputs
Click **Run Test**

**When Executing:**

Click **Execute Workflow** in the toolbar
Variable Panel appears
Enter input values
Click **Execute**

**When Triggering via Webhook:**

Input values come from webhook payload
No manual input required
Payload must match input schema

**Input Value Types:**

**Text**: Plain text string
**Number**: Integer or decimal
**Boolean**: true or false
**JSON**: Complex data structure
**Array**: List of values
**File**: File upload (for attachments)

Previewing Resolved Values

The Variable Panel shows how variables will be resolved during execution.

**Preview Features:**

Shows final values after substitution
Highlights variable references
Updates in real-time as you type
Validates variable syntax

**Example Preview:**

Original: New lead: ${input.lead_name}
Resolved: New lead: John Doe

Original: Lead ID: ${step_create_lead.lead_id}
Resolved: Lead ID: (pending execution)

**Color Coding:**

**Blue**: Variable reference
**Black**: Static text
**Gray**: Pending execution
**Red**: Error (invalid variable)

---

Testing and Execution

Testing Individual Nodes

Test nodes individually before running the full workflow.

**How to Test a Node:**

Select the node on the canvas
Click **Test Node** in the configuration panel
Provide test input values
Click **Run Test**
View test results

**Test Results Show:**

Success/failure status
Output data
Execution time
Error messages (if any)

**Example: Test Slack Node**

Input:
  channel: #test
  message: Test message from ATUM

Output:
  success: true
  message_ts: "123456.789"
  channel: "#test"

Execution Time: 245ms

**Use Cases:**

Verify integration credentials
Test API calls
Validate variable substitution
Debug node configuration

Executing Workflows

Execute the entire workflow from the toolbar.

**Steps:**

Click **Execute Workflow** in the toolbar
Variable Panel appears
Enter input values
Click **Execute**
Monitor execution progress

**Execution Modes:**

**1. Test Mode**

Executes workflow with test data
No side effects (integrations not called)
Fast execution
Useful for development

**2. Live Mode**

Executes workflow with real data
Integrations are called
Side effects occur
Useful for production

**Select Mode:**

Toggle between Test/Live in the toolbar
Test mode is default
Live mode shows warning

Viewing Execution Results

After execution, view detailed results.

**Results Panel:**

Execution ID: exec-456
Status: Completed
Started: 2026-03-28 15:30:00
Completed: 2026-03-28 15:30:05
Duration: 5.2s

Step Results:
  ✓ Step 0: Webhook Trigger (50ms)
  ✓ Step 1: Create Salesforce Lead (1.2s)
  ✓ Step 2: Send Slack Message (3.9s)

Output:
  lead_id: "001xx000003DGb2A"
  success: true
  message_ts: "123456.789"

**Step Details:**

Click a step to view details
See input parameters
See output data
View error messages (if any)

**Export Results:**

Click **Export Results** in the toolbar
Download as JSON
Download as CSV
Copy to clipboard

Debugging Failed Executions

When a workflow fails, debug the issue.

**Failure Types:**

**1. Integration Not Connected**

Error: "Slack integration not connected"
Solution: Click integration to connect OAuth
Retry: After connecting, re-execute workflow

**2. Missing Input Values**

Error: "Required input 'lead_name' not provided"
Solution: Provide value in Variable Panel
Retry: Re-execute with correct values

**3. Variable Reference Error**

Error: "Variable 'step_1.lead_id' not found"
Solution: Check step ID or index
Retry: Fix variable reference and re-execute

**4. Governance Block**

Error: "Agent maturity level insufficient for this action"
Solution: Upgrade agent maturity or change operation
Retry: Re-execute with appropriate permissions

**5. Quota Exceeded**

Error: "Daily workflow execution quota exceeded"
Solution: Upgrade plan or wait for quota reset
Retry: Execute after quota reset

**Debugging Tips:**

**Check Logs**: View detailed logs for each step
**Test Individually**: Test failing node in isolation
**Verify Inputs**: Ensure input values are correct
**Check Connections**: Verify integrations are connected
**Review Governance**: Check agent maturity levels
**Monitor Quota**: Check plan limits

---

Saving Workflows

Save your workflow to continue editing later.

**Steps:**

Click **Save Workflow** in the toolbar
Enter workflow name
Enter description (optional)
Click **Save**

**Saved Workflows:**

Appear in **My Workflows** section
Can be loaded into canvas
Can be edited
Can be executed

**Auto-Save:**

Workflows auto-save every 30 seconds
Last saved time shown in toolbar
Manual save overrides auto-save

Saving as Template

Save your workflow as a template for reuse or sharing.

**Steps:**

Click **Save as Template** in the toolbar
Enter template metadata:

Name: "Salesforce to Slack Lead Sync"
Description: "Sync new Salesforce leads to Slack channel"
Category: Integration
Complexity: Beginner
Tags: salesforce, slack, sync, leads

Choose visibility:

**Private**: Only you can see and use
**Public**: Anyone can see and use (requires approval)

Click **Save Template**

**Template Metadata:**

**Name:**

Short, descriptive title
Example: "Salesforce to Slack Lead Sync"

**Description:**

What the workflow does
When to use it
Required integrations
Example: "Syncs new Salesforce leads to a Slack channel for instant sales team notification."

**Category:**

Integration: Connect services
Automation: Automate tasks
Approval: Multi-step approvals

**Complexity:**

Beginner: Simple workflows (1-3 steps)
Intermediate: Moderate complexity (4-6 steps)
Advanced: Complex workflows (7-10 steps)
Expert: Highly complex (10+ steps)

**Tags:**

Comma-separated keywords
Helps with searchability
Example: salesforce, slack, sync, leads, crm

Template Metadata

When saving as a template, provide metadata for discoverability.

**Required Fields:**

Name
Description
Category
Complexity

**Optional Fields:**

Tags
Estimated duration
Required integrations
Example inputs

**Best Practices:**

Use descriptive names
Write clear descriptions
Choose appropriate category
Set accurate complexity
Add relevant tags
Provide example inputs

**Example:**

Name: Salesforce to Slack Lead Sync
Description: |
  Sync new Salesforce leads to a Slack channel for instant sales team notification.
  Perfect for sales teams who want real-time lead alerts in Slack.
Category: Integration
Complexity: Beginner
Tags: salesforce, slack, sync, leads, crm, notification
Estimated Duration: 5 seconds
Required Integrations:
  - Salesforce (query leads)
  - Slack (send message)
Example Inputs:
  slack_channel: "#sales"
  lead_limit: 10

Making Templates Public

Share your templates with the ATUM community.

**Visibility Options:**

**Private (Default)**

Only you can see and use
Appears in **My Templates**
No approval required

**Public**

Anyone can see and use
Appears in **Public Templates**
Requires approval
Can be featured

**How to Make Public:**

Save as template
Set visibility to **Public**
Submit for approval
Wait for review (usually 24-48 hours)
Template appears in public gallery

**Approval Criteria:**

Workflow must execute successfully
Documentation must be clear
Template must be useful
No security vulnerabilities
Follows best practices

**Benefits of Public Templates:**

Community recognition
Help other users
Showcase your expertise
Potential featured placement

---

Tips and Best Practices

Workflow Design Patterns

**1. Sequential Pattern**

Execute steps one after another.

Step 1 → Step 2 → Step 3

**Use Cases:**

Data pipelines
Multi-stage transformations
Sequential approvals

**2. Parallel Pattern**

Execute multiple steps simultaneously.

Step 1 → Step 2 → Step 3
        ↓
      Step 4 → Step 5

**Use Cases:**

Multi-channel notifications
Batch processing
Redundant operations

**3. Branching Pattern**

Execute different paths based on conditions.

Step 1 → Condition → True Path
                → False Path

**Use Cases:**

Lead qualification
Error handling
A/B testing

**4. Loop Pattern**

Iterate over items and process each.

Step 1 (list items) → Loop → Process Item → Continue
                            ↑__________________↓

**Use Cases:**

Batch processing
Bulk operations
Iterative transformations

**5. Error Handling Pattern**

Handle errors gracefully and continue.

Step 1 → Try Operation → Success → Continue
                    → Error → Log Error → Continue

**Use Cases:**

Resilient workflows
Partial success handling
Error recovery

Common Pitfalls

**1. Circular Dependencies**

**Problem**: Node A depends on Node B, Node B depends on Node A
**Solution**: Redesign workflow to eliminate circular dependencies
**Detection**: Workflow builder shows warning

**2. Missing Variable References**

**Problem**: Referencing non-existent variables
**Solution**: Check variable names and step IDs
**Detection**: Variable panel shows errors

**3. Unconnected Nodes**

**Problem**: Nodes not connected to the main flow
**Solution**: Connect all nodes or remove unused nodes
**Detection**: Visual indicator on canvas

**4. Hard-coded Values**

**Problem**: Using hard-coded values instead of variables
**Solution**: Use variables for dynamic data
**Best Practice**: ${input.field} instead of "value"

**5. No Error Handling**

**Problem**: Workflow fails on first error
**Solution**: Add error handling nodes
**Best Practice**: Use try/catch patterns

**6. Complex Workflows**

**Problem**: Too many nodes in one workflow
**Solution**: Split into smaller workflows
**Best Practice**: Keep workflows under 20 nodes

**7. Missing Integration Connections**

**Problem**: Integration nodes without OAuth
**Solution**: Connect integrations before execution
**Detection**: Red badge on integration nodes

Performance Optimization

**1. Minimize Node Count**

Fewer nodes = faster execution
Combine related operations
Use sub-workflows for reuse

**2. Use Parallel Execution**

Execute independent steps simultaneously
Reduces total execution time
Useful for multi-channel operations

**3. Cache Frequently Used Data**

Store results in variables
Avoid redundant API calls
Use caching where available

**4. Optimize API Calls**

Batch operations when possible
Use filters to reduce data transfer
Limit query results

**5. Choose Efficient Integrations**

Some integrations are faster than others
Test integration performance
Use recommended integrations

Security Considerations

**1. Protect Sensitive Data**

Don't hard-code API keys
Use integration credentials
Mask sensitive values in logs

**2. Validate Input Data**

Define input schemas
Use validation rules
Sanitize user input

**3. Follow Principle of Least Privilege**

Use minimum required permissions
Restrict agent maturity levels
Limit integration scopes

**4. Audit Workflow Execution**

Review execution logs
Monitor for suspicious activity
Set up alerts for failures

**5. Test Before Production**

Test workflows thoroughly
Use test mode first
Gradually roll out to production

---

Troubleshooting

Common Errors and Solutions

**Error 1: "Integration not connected"**

**Cause**: OAuth credentials not configured
**Solution**: Click integration badge to connect
**Prevention**: Connect integrations before building workflows

**Error 2: "Variable not found: ${input.name}"**

**Cause**: Input variable not defined or misspelled
**Solution**: Check variable name in workflow settings
**Prevention**: Use variable panel to insert variables

**Error 3: "Agent maturity level insufficient"**

**Cause**: Agent cannot perform requested action
**Solution**: Upgrade agent maturity or change operation
**Prevention**: Check maturity requirements before adding nodes

**Error 4: "Quota exceeded"**

**Cause**: Plan limit reached
**Solution**: Upgrade plan or wait for reset
**Prevention**: Monitor usage and optimize workflows

**Error 5: "Workflow execution timeout"**

**Cause**: Workflow took too long to execute
**Solution**: Optimize workflow or increase timeout
**Prevention**: Keep workflows under 5 minutes

Integration Connection Issues

**Problem: Cannot connect integration**

**Solutions:**

**Check OAuth Status**

Go to Integrations page
Verify integration is connected
Reconnect if necessary

**Check Permissions**

Verify OAuth scopes are correct
Grant required permissions
Re-authorize if needed

**Check Network**

Verify internet connection
Check firewall settings
Try different browser

**Clear Cache**

Clear browser cache
Clear ATUM cache
Log out and log back in

**Problem: Integration connected but still failing**

**Solutions:**

**Verify Credentials**

Check API keys are valid
Verify OAuth token is not expired
Refresh credentials

**Test Integration**

Go to Integrations page
Click "Test Connection"
Review test results

**Check Integration Status**

Visit integration status page
Check for service outages
Review status updates

Governance Restrictions

**Problem: Agent cannot perform action**

**Solutions:**

**Check Maturity Level**

Verify agent maturity
Review action requirements
Upgrade maturity if needed

**Review Restrictions**

Check governance restrictions
Understand what's allowed
Adjust workflow accordingly

**Use Different Agent**

Select higher maturity agent
Create new agent with appropriate maturity
Use autonomous agent for full access

**Problem: Agent approval required**

**Solutions:**

**Provide Approval**

Review proposed action
Approve or reject
Provide feedback

**Upgrade Maturity**

Move agent to higher maturity
Bypass approval requirement
Use supervised or autonomous agent

**Adjust Workflow**

Use agent for allowed actions
Use integration nodes for restricted actions
Split workflow appropriately

Getting Help

**Documentation**

**Community**

ATUM Community Forum
Slack Community
Stack Overflow (atum-saas tag)

**Support**

Email Support: support@atum-saas.com
In-App Help: Click **Help** button in toolbar
Submit Ticket: Use contact form

**Resources**

Video Tutorials
Webinars
Blog Posts
Example Workflows

---

**User Guide Version:** 1.0.0

**Last Updated:** 2026-03-28

**Maintained By:** ATUM SaaS Documentation Team

For the latest updates and announcements, follow us on Twitter @ATUM_SaaS.

Workflow Builder User Guide

Table of Contents

Getting Started

Accessing the Visual Workflow Builder

Interface Overview

Quick Start: Create Your First Workflow

Using Templates

Browsing Template Gallery

Filtering by Category

Previewing Templates

Loading Template into Canvas

Customizing Loaded Templates

Working with Nodes

Adding Nodes to Canvas

Integration Nodes

Entity Nodes

Agent Nodes

Trigger Nodes

Control Flow Nodes

Connecting Nodes

Creating Connections Between Nodes

Setting Up Conditional Paths

Branching Workflows

Configuring Workflows

Node Configuration Panel

Setting Parameters

Using Variables

Variable Reference Syntax

Variables and Inputs

Understanding ${input.field} Variables

Using ${step_N.field} References

Variable Substitution Panel

Providing Input Values

Previewing Resolved Values

Testing and Execution

Testing Individual Nodes

Executing Workflows

Viewing Execution Results

Debugging Failed Executions

Saving and Sharing

Saving Workflows

Saving as Template

Template Metadata

Making Templates Public

Tips and Best Practices

Workflow Design Patterns

Common Pitfalls

Performance Optimization

Security Considerations

Troubleshooting

Common Errors and Solutions

Integration Connection Issues

Governance Restrictions

Getting Help